# -*- coding: utf-8 -*-
"""
使用百度翻译 API 将 `球员数据英文.txt` 中的每个球员姓名翻译为中文，
并保留原始的引号/逗号格式。翻译后的姓名内部词间使用“·”分隔（例如：勒布朗·詹姆斯）。
将结果写入 `球员数据中文.txt`。

说明：
- 本脚本参考了项目中的 Baidu_Text_transAPI.py 示例实现。
- 逐行处理输入文件，保留每行的前后原始字符（如开头的引号和末尾的'",'等）。
- 若翻译失败，回退为将英文姓名的空格替换为“·”并保留原有格式。
"""

import requests
import random
import json
import time
from hashlib import md5
import sys
import os

# ========== Baidu 翻译 API 配置（来自示例） ==========
appid = 'your_appid'
appkey = 'your_appkey'
endpoint = 'http://api.fanyi.baidu.com'
path = '/api/trans/vip/translate'
url = endpoint + path

from_lang = 'en'
to_lang = 'zh'

# ========== 辅助函数 ==========
def make_md5(s, encoding='utf-8'):
    """生成 MD5 签名（中文注释）"""
    return md5(s.encode(encoding)).hexdigest()

def translate_text(q):
    """
    调用百度翻译 API 翻译单条字符串 q。
    返回翻译后的字符串（unicode），若失败则抛出异常。
    """
    salt = str(random.randint(32768, 65536))
    sign = make_md5(appid + q + salt + appkey)
    headers = {'Content-Type': 'application/x-www-form-urlencoded'}
    payload = {
        'appid': appid,
        'q': q,
        'from': from_lang,
        'to': to_lang,
        'salt': salt,
        'sign': sign
    }
    try:
        # 使用 POST 提交表单
        r = requests.post(url, params=payload, headers=headers, timeout=10)
        # 在发送请求后打印日志，便于追踪每次翻译请求（用户要求）
        print("已发送翻译请求：{}".format(q))
        r.raise_for_status()
        result = r.json()
        # 检查返回结构
        if 'trans_result' in result and isinstance(result['trans_result'], list):
            return result['trans_result'][0]['dst']
        else:
            # 若遇到错误码，抛出异常，便于上层处理
            raise RuntimeError("翻译响应格式异常: {}".format(result))
    except Exception as e:
        raise

def preserve_format_and_replace(name_line, translated_name):
    """
    保留原始行的引号/逗号等包裹格式，将翻译好的姓名填回并返回新行。
    逻辑：
      - 寻找首个和最后一个双引号，抽取中间为原始姓名
      - prefix = 从文件行开头到首个双引号（包含首个双引号）
      - suffix = 从最后一个双引号到行尾（包含最后一个双引号及可能的逗号/空白）
      - 返回 prefix + translated_name + suffix
    若该行没有双引号（极少数情况），则尝试保留尾部逗号并按原格式返回。
    """
    line = name_line
    if '"' in line:
        first = line.find('"')
        last = line.rfind('"')
        prefix = line[:first+1]   # 包含首个双引号
        suffix = line[last:]      # 包含末尾双引号及后缀（如逗号）
        return prefix + translated_name + suffix
    else:
        # 没有双引号：尝试把行按第一个逗号分割
        if ',' in line:
            parts = line.split(',', 1)
            return translated_name + ',' + (parts[1] if len(parts)>1 else '')
        else:
            return translated_name

def post_process_translated(dst):
    """
    对翻译结果进行后处理：
      - 将英文空格替换为中文姓名常用连接点 '·'，以分隔名字与姓氏
      - 去除首尾空白
      - 如果翻译结果里已经没有空格（例如直接返回中文），则直接返回
    注意：这里的策略简单且通用，能产生“名字·姓氏”形式的显示。
    """
    if not dst:
        return dst
    dst = dst.strip()
    # 如果已经包含中文字符，直接将所有空格替换为 '·'
    # 否则同样替换空格（亦适用于部分仍为拉丁字母的情况）
    dst = dst.replace(' ', '·')
    # 合并可能产生的连续分隔符
    while '··' in dst:
        dst = dst.replace('··', '·')
    return dst

# ========== 主流程 ==========
def main():
    in_path = '球员数据英文.txt'
    out_path = '球员数据中文.txt'

    if not os.path.exists(in_path):
        print("未找到输入文件: {}".format(in_path), file=sys.stderr)
        sys.exit(1)

    # 支持断点续传：检查目标文件已存在的行数，从下一行开始翻译并在翻译后立即追加写入
    existing_count = 0
    if os.path.exists(out_path):
        try:
            with open(out_path, 'r', encoding='utf-8') as fr:
                for _ in fr:
                    existing_count += 1
        except Exception as e:
            print("读取目标文件失败，继续从头开始：{}".format(e), file=sys.stderr)
            existing_count = 0

    # 逐行读取输入源
    with open(in_path, 'r', encoding='utf-8') as f:
        lines = f.readlines()

    # 如果目标文件不存在，先创建一个空文件以便以追加模式写入
    if not os.path.exists(out_path):
        open(out_path, 'w', encoding='utf-8').close()

    # 逐行处理，从 existing_count+1 的下一行开始
    for idx, raw_line in enumerate(lines, 1):
        # 跳过已经翻译并写入的行（断点续传）
        if idx <= existing_count:
            continue

        line = raw_line.rstrip('\n')
        # 空行直接写入并继续
        if line.strip() == '':
            with open(out_path, 'a', encoding='utf-8') as fo:
                fo.write(line + '\n')
            print("已写入第{}行（空行）".format(idx))
            continue

        # 提取原始姓名（双引号内）作为翻译内容
        if '"' in line:
            first = line.find('"')
            last = line.rfind('"')
            name_en = line[first+1:last]
        else:
            # 若没有双引号，则以逗号分割取第一个字段
            name_en = line.split(',', 1)[0].strip()

        # 尝试调用翻译接口：将姓名拆分为词，分别翻译，然后用 '·' 连接，降低翻译不稳定性
        translated = None
        try:
            import re
            parts = [p for p in re.split(r'\s+', name_en) if p]
            translated_parts = []
            for part in parts:
                # 对每个词单独翻译（translate_text 内部会打印已发送翻译请求）
                translated_part_raw = translate_text(part)
                translated_part = post_process_translated(translated_part_raw)
                translated_parts.append(translated_part)
                # 小睡以降低并发请求压力
                time.sleep(0.11)
            if translated_parts:
                translated = '·'.join(translated_parts)
            else:
                translated = name_en.replace(' ', '·')
        except Exception as e:
            # 回退：直接用原始英文名按空格替换为 '·'
            translated = '·'.join([p for p in name_en.split() if p]) if name_en.strip() else name_en
            # 记录到 stderr，便于排查
            print("第 {} 行分词翻译失败，回退到替代方案: {}  错误: {}".format(idx, name_en, e), file=sys.stderr)

        # 组合保留原始格式的输出行
        out_line = preserve_format_and_replace(line, translated)

        # 将翻译结果立即追加到目标文件，实现每完成一次翻译就写入的行为
        try:
            with open(out_path, 'a', encoding='utf-8') as fo:
                fo.write(out_line + '\n')
                fo.flush()
            print("已翻译并写入第{}行：{}".format(idx, out_line))
        except Exception as e:
            print("写入目标文件失败（第{}行）：{}".format(idx, e), file=sys.stderr)

    print("翻译过程完成，目标文件：{}".format(out_path))

if __name__ == '__main__':
    main()
